
#### Table of Contents

1. Get Start
2. Connect to the MongoDB
3. Defined MongoDB Schema
4. Find data from MongoDB
5. Conclusion

This blog will show a tutorial about how to find data into MongoDB by using
Node.js with Mongoose. Mongoose is the Object Data Modeling library for
MongoDB and Node.js. It provides functions for schema, query building, and
more. If you don't use Mongoose to access MongoDB with Node.js, then you can
use the MongoDB package for Node.js directly.

## Get Start

First, initialize a new npm package, we'll create a new package and new file,
and add our code for how to insert data to MongoDB.

```
npm init -y
```

Next, let's install the mongoose package, this will be the only package we'll
use for this tutorial.

```
npm install --save mongoose
```

Create an **index.js**, we'll add our code to this file to
connect to MongoDB and insert data to the Database.

## Connect to the MongoDB

Now, the following is a sample code to connect to MongoDB. Assume you already
set up MongoDB at your local and has a database as
**your-database**.

```
const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() => {
    console.info('connect successfully')
})
.catch(() => {
    console.error('connection error');
});
```

## Defined MongoDB Schema

Here, we'll define our collection in MongoDB, the collection name will be
**my-collection-name**.

```
let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');
```

## Find data from MongoDB

Now, this is the final step we'll find data from this collection after this
code had run it should return a list of result match the key is 'test-key'
from collection **my-collection-name**.

```
const getDataAsync = async() => {

    let result = await localSchema.find({key: 'test-key'});

}

getDataAsync();
```

If you only expect to return one record, you can do the following query.

```
const getOneAsync = async() => {

    let result = await localSchema.findOne({key: 'test-key'});
    console.info(result);
}

getOneAsync();
```

If you want to find the one then update it, you can try the following code.
It'll find then update with the new value.

```
const getAndModifyAsync = async() => {

    let result = await localSchema.findOneAndUpdate({key: 'test-key'}, {
        value: "my new value"
    })
}

getAndModifyAsync();
```

### Conclusion

Above is how you can get data from MongoDB by using Node.js with Mongoose.


This blog will show a tutorial about how to find data into MongoDB by using Node.js with Mongoose.

How to Find Record from MongoDB with Node.js and Mongoose


#### Table of Contents

1. Get Start
2. Connect to the MongoDB
3. Defined MongoDB Schema
4. Insert some data to MongoDB
5. Try delete Records with Mongoose
6. Conclusion

This blog will show a tutorial about how to delete data from MongoDB by using
Node.js with Mongoose. Mongoose is the Object Data Modeling library for
MongoDB and Node.js. It provides functions for schema, query building, and
more. If you don't use Mongoose to access MongoDB with Node.js, then you can
use the MongoDB package for Node.js directly.

## Get Start

First, initialize a new npm package, we'll create a new package and new file,
and add our code for how to insert data to MongoDB.

```
npm init -y
```

Next, let's install the mongoose package, this will be the only package we'll
use for this tutorial.

```
npm install --save mongoose
```

Create an **index.js**, we'll add our code to this file to
connect to MongoDB and insert data to the Database.

## Connect to the MongoDB

Now, the following is a sample code to connect to MongoDB. Assume you already
set up MongoDB at your local and has a database as
**your-database**.

```
const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() => {
    console.info('connect successfully')
})
.catch(() => {
    console.error('connection error');
});
```

## Defined MongoDB Schema

Here, we'll define our collection in MongoDB, the collection name will be
**my-collection-name**.

```
let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');
```

## Insert some data to MongoDB

Before we can try the Mongoose Delete function, let's add some test data. The
following code will add 100 different records into the collection.

```
const createTestMillionAsync = async(roopLimit) => {
    let timerName = `insert-timer-${roopLimit}`;
    console.time(timerName)
    let testTargetList = [];
    for (let index = 0; index < roopLimit; index++) {

        testTargetList.push({
            key: `test-key-${index}`,
            value: `my test value : ${index}`,
            culture: 'en-US'
        });

    }

    await localSchema.insertMany(testTargetList);

    console.timeEnd(timerName);
}

createTestMillionAsync(100);
```

## Try delete Records with Mongoose

The following is example is for deleting the specific record, so you just need
to call the deleted one and pass the _id value.

```
const removeDataAsync = async() => {

  let result = await localSchema.deleteOne({
        _id: '60a872a9d3ed022504e3aa01'
    });
    if (result) {
        console.info('update successfully', result);
    }
}

removeDataAsync();
```

In case you want to delete everything from the collection, you can try the
following code.

```
const removeDataAsync = async() => {

    let result = await localSchema.deleteMany({});
    if (result) {
        console.info('update successfully', result);
    }
}

removeDataAsync();
```

### Conclusion

Above is how you can use the delete function with Mongoose to MongoDB by using
Node.js.


This blog will show a tutorial about how to delete data from MongoDB by using Node.js with Mongoose.

How to Delete Data from MongoDB with Node.js and Mongoose


#### Table of Contents

1. Get Start
2. Connect to the MongoDB
3. Defined MongoDB Schema
4. Update data from MongoDB
5. Conclusion

This blog will show a tutorial about how to update data into MongoDB by using
Node.js with Mongoose. Mongoose is the Object Data Modeling library for
MongoDB and Node.js. It provides functions for schema, query building, and
more. If you don't use Mongoose to access MongoDB with Node.js, then you can
use the MongoDB package for Node.js directly.

## Get Start

First, initialize a new npm package, we'll create a new package and new file,
and add our code for how to insert data to MongoDB.

```
npm init -y
```

Next, let's install the mongoose package, this will be the only package we'll
use for this tutorial.

```
npm install --save mongoose
```

Create an **index.js**, we'll add our code to this file to
connect to MongoDB and insert data to the Database.

## Connect to the MongoDB

Now, the following is a sample code to connect to MongoDB. Assume you already
set up MongoDB at your local and has a database as
**your-database**.

```
const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() => {
    console.info('connect successfully')
})
.catch(() => {
    console.error('connection error');
});
```

## Defined MongoDB Schema

Here, we'll define our collection in MongoDB, the collection name will be
**my-collection-name**.

```
let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');
```

## Update data from MongoDB

Now, this is the final step we'll find data from the collection, then update
the data. Following code will first find records by key 'test-key', then
update the value field.

```
const updateDataAsync = async() => {

    let result = await localSchema.find({key: 'test-key'});
    if (result) {
        let updateResult = await localSchema.updateOne({
            _id: result[0]._id
        }, {
            value: 'test3'
        });
        if (updateResult) {
            console.info('update successfully')
        }
    }
}

updateDataAsync();
```

### Conclusion

Now, above is how you can update data from MongoDB by using Node.js with
Mongoose.


How to Update MongoDB Data with Node.js and Mongoose


#### Table of Contents

1. Get Start
2. Connect to the MongoDB
3. Defined MongoDB Schema
4. Insert new data into MongoDB
5. Insert Data to MongoDB by using mongoose.create
6. Conclusion

This blog will show a tutorial about how to insert data into MongoDB by using
Node.js with Mongoose. Mongoose is the Object Data Modeling library for
MongoDB and Node.js. It provides functions for schema, query building, and
more. If you don't use Mongoose to access MongoDB with Node.js, then you can
use the MongoDB package for Node.js directly.

## Get Start

First, initialize a new npm package, we'll create a new package and new file,
and add our code for how to insert data to MongoDB.

```
npm init -y
```

Next, let's install the mongoose package, this will be the only package we'll
use for this tutorial.

```
npm install --save mongoose
```

Create an **index.js**, we'll add our code to this file to
connect to MongoDB and insert data to the Database.

## Connect to the MongoDB

Now, the following is a sample code to connect to MongoDB. Assume you already
set up MongoDB at your local and has a database as
**your-database**.

```
const {connect} = require('mongoose');

connect('mongodb://localhost:27017/your-database')
.then(() => {
    console.info('connect successfully')
})
.catch(() => {
    console.error('connection error');
});
```

## Defined MongoDB Schema

Here, we'll define our collection in MongoDB, the collection name will be
**my-collection-name**.

```
let localModel = new Schema({
    key: {
        type: String
    },
    value: {
        type: String
    },
    culture: {
        type: String
    }
})

let localSchema = model('localization', localModel, 'my-collection-name');
```

## Insert new data into MongoDB

Now, this is the final step we'll insert new data into the collection, we'll
use **insertMany.** after this code it should insert new data
into the collection **my-collection-name**.

```
localSchema.insertMany({
    key: 'test-key',
    value: 'key description',
    culture: 'en-US'
}).then(function() {
    console.info('insert new data successfully')
}).catch(function() {
    console.error('has error when insert new data');
})
```

### Insert Data to MongoDB by using mongoose.create

Another way to insert into data is following, but then which one is better?
Should I use insert or create.

```
const createAsync = async() => {
    await localSchema.create({
        key: 'test-key-2',
        value: 'key2 description',
        culture: 'en-US'
    });
}

createAsync();
```

So, looks like it is better to use mongoose.insert because it's faster and
less issue. So I did some research by insert 100,000 records into MongoDB.

When I execute the following record on my macOS, the insert-timer's time was
11922.764ms.

```
const createTestMillionAsync = async() => {
    console.time('insert-timer')
    let testTargetList = [];
    for (let index = 0; index < 100000; index++) {

        testTargetList.push({
            key: `test-key-${index}`,
            value: `my test value : ${index}`,
            culture: 'en-US'
        });

    }

    await localSchema.insertMany(testTargetList);

    console.timeEnd('insert-timer');
}

createTestMillionAsync();
```

However, when I tried following 100,000 records with creating I was getting
timed out error, the default connection time out is 10000ms.

```
const createTestMillionAsync = async(roopLimit) => {
    let timerName = `insert-timer-${roopLimit}`;
    console.time(timerName)
    let testTargetList = [];
    for (let index = 0; index < roopLimit; index++) {

        testTargetList.push({
            key: `test-key-${index}`,
            value: `my test value : ${index}`,
            culture: 'en-US'
        });

    }

    await localSchema.insertMany(testTargetList);

    console.timeEnd(timerName);
}

createTestMillionAsync(100000);
```

So I extend the connectionTimeout from 10000 to 50000, re-run as following
combination, you can see that insertMany are 7 times faster than create.

| **Records** | **mongoose.create** | **mongoose.insertMany** |
| --- | --- | --- |
| 100000 | 75261.921ms | 11869.793.ms |
| 500000 | Error: Javascript heap out of memory | 61775.343ms |

### Conclusion

Above is how you can insert new data into MongoDB with Node.js with Mongoose.
Looks like it's better to use InsertMany for better performance.


This blog will show a tutorial about how to insert data into MongoDB by using Node.js with Mongoose.

How to Insert Data into MongoDB with Node.js and Mongoose


Get all records where the Ids contains specfic object Id.

```
var q= yourCollection.find({ Ids: mongoose.Types.ObjectId('539ba44481973asdfe0c402bc6') });
    q.exec(function (err, items)
    {
        console.info(err);
        console.info(items.length);
    });
```


Get all records where the Ids contain specific object Id with Mongoose.

Code Snippet - How to Find Items by ObjectId with Mongoose


#### Table of Contents

1. How to use MongoDB text search
2. Stop Words, Stemming in MongoDB text search
3. Now, let's get started how to use MongoDB text search
4. What's going on, doesn't work!
5. So, what's I do?
6. How does Mongodb define score for text search?

## How to use MongoDB text search

MongoDB provide text search function since 2.4, this blog will show how to use
mongodb text search.

All the example at following is run based on MongoDB version, 3.0.5. Also, I'm
using Robomongo (0.8.5) to run all the MongoDB command.

I also have code snippet about how to use Mongoose with text search, but I
recommend at least use 2.6, seems like 2.4 with Mongoose has some problem.

### Stop Words, Stemming in MongoDB text search

Before jump into how to use MongoDB text search, we need to understand how
MongoDB do stop words and stemming. **Stop** in MongoDB is, let's
say you have "I like apple", stop wold will be **apple**.
**Stemming** is like "cook cooking cooks", so MongoDB text engine
will index cook.

> I like apple, also I enjoy cooking.

Above example, MongoDB will index `apple` and `cook`,
There is very good blog about this topic, text-search-mongodb-stemming.

### Now, let's get started how to use MongoDB text search

###### Get MongoDB's version

This command will tell you what version of MongoDB you're using.

```
db.version()
// 3.0.5
```

###### Get Current MongoDB database name

This will return your current db name. Before you run you query you need to
check you're running to the correct mongodb or not right?

```
db.getName()
// the current database name.
```

###### Check Index of current collection

You can run following command, if you want to check your collection had add
text index or other index or not.

Following example is how I check my collection
`Posts `contains any index or not.

```
// You run this
db.posts.getIndexes()
```

```
// Then will some result like this or if there's no index then just empty json. Now as you can see following example contains no text search index.
{
    "0" : {
        "v" : 1,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "dake-tech.posts"
    },
    "1" : {
        "v" : 1,
        "unique" : true,
        "key" : {
            "slug" : 1
        },
        "name" : "slug_1",
        "ns" : "dake-tech.posts",
        "background" : true,
        "safe" : null
    }
}
```

Now, we're going to add text index to this collection.First the collection
`Posts` looks like following. I'd like to add create text index to
`content.brief & content.extended & title`

```
{
    "_id" : ObjectId("535cc04cd06eabf033ee36bc"),
    "__v" : 0,
    "author" : ObjectId("535c4fe25115d24c0c4cf84b"),
    "categories" : [],
    "content" : {
        "brief" : "
Looks like http://embed.ly/ is greate site, if I want to create something with URL. It'll get the short version of the url's detail. I have thought about imprement these kind of stuff, but since somebody already create this, why not just use it.


```
`\r\n`
```


```
`\r\n`
```


Nextime, i'll post some detail when I use it.


```
`",
"extended" : ""
},
"publishedDate" : ISODate("2014-04-01T07:00:00.000Z"),
"slug" : "embedly-get-url-link-detail",
"state" : "published",
"title" : "embed.ly - Get url link detail"
}
```


First, let's add text index to title`


db.posts.ensureIndex({title: "text"});
```

After I create text index to the `title`field, and run
`db.posts.getIndexes()` again to check my index, I got following
new added index. Cool, I had added text index to my Posts.Title.

```
"4" : {
        "v" : 1,
        "key" : {
            "_fts" : "text",
            "_ftsx" : 1
        },
        "name" : "title_text",
        "ns" : "dake-tech.posts",
        "weights" : {
            "title" : 1
        },
        "default_language" : "english",
        "language_override" : "language",
        "textIndexVersion" : 2
    }
```

Now, mongodb also has YouCollection.validate() which will validate your
index.So when I run `db.posts.validate()` I got following result
about my title field's text index. So cool right, the
`"dake-tech.posts.$title_text" : 1464` is telling you the
post.title indexed `1464`keys words.

```
{
    "ns" : "dake-tech.posts",
    "datasize" : 4.72926e+006,
    "nrecords" : 325,
    "lastExtentSize" : 1.67772e+007,
    "firstExtent" : "0:ef000 ns:dake-tech.posts",
    "lastExtent" : "0:351000 ns:dake-tech.posts",
    "extentCount" : 4,
    "firstExtentDetails" : {
        "loc" : "0:ef000",
        "xnext" : "0:111000",
        "xprev" : "null",
        "nsdiag" : "dake-tech.posts",
        "size" : 8192,
        "firstRecord" : "0:ef0b0",
        "lastRecord" : "0:f0eb0"
    },
    "lastExtentDetails" : {
        "loc" : "0:351000",
        "xnext" : "null",
        "xprev" : "0:151000",
        "nsdiag" : "dake-tech.posts",
        "size" : 1.67772e+007,
        "firstRecord" : "0:3510b0",
        "lastRecord" : "0:591230"
    },
    "deletedCount" : 5,
    "deletedSize" : 1.44095e+007,
    "nIndexes" : 5,
    "keysPerIndex" : {
        "dake-tech.posts.$_id_" : 325,
        "dake-tech.posts.$slug_1" : 325,
        "dake-tech.posts.$state_1" : 325,
        "dake-tech.posts.$publishedDate_1" : 325,
        "dake-tech.posts.$title_text" : 1464
    },
    "valid" : true,
    "errors" : [],
    "warning" : "Some checks omitted for speed. use {full:true} option to do more thorough scan.",
    "ok" : 1.0000000000000000
}
```

###### Now, let's do text search

When you type `db.posts.runCommand("text", {search: "mongodb"})`,
you might get result as following.

```
{
    "ok" : 0.0000000000000000,
    "errmsg" : "no such command: text",
    "code" : 59,
    "bad cmd" : {
        "text" : "posts",
        "search" : "mongodb"
    }
}
```

### What's going on, doesn't work!

You might able to try following, go to admin enable the text search. However
you will still get the same result. What happening is following command looks
like works for the old MongoDB, maybe 2.4 to 2.6. However, if you use latest
MongoDB (3.0 or above), text search is enable by default, and
`runCommand("text",` is no longer exist.

```
use admin
db.runCommand({setParameter: 1, textSearchEnabled: true})

db.posts.runCommand("text", {search: "mongodb"})

{
    "was" : true,
    "ok" : 1.0000000000000000
}
```

### So, what's I do?

If you mongodb version is 3.0 or above like my current MongoDB, 3.0.5. You can
try following.

```
db.posts.find( { $text: { $search: "javascript" } } )
```

Also, following is the result I got. Awesome, right!? you got 12 results.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_0eg17u58c.png)

Now, I'm going to add text index to my result of fields,
`content.brief` and `content.extended`, So you type...
`db.posts.ensureIndex({'content.brief': 'text'});`. Then you got
this error, what's going on!!? I can only add once!?

```
{
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 3,
    "errmsg" : "exception: Index with pattern: { _fts: \"text\", _ftsx: 1 } already exists with different options",
    "code" : 85,
    "ok" : 0
}
```

The result is, at current version 3.0.5, you can only add one text index, if
you want to add multi fields for text search, you could do as following.
First, you run `db.posts.dropIndex('title_text')`, so you can drop
the old text index.

This is the result you will get.

```
{
    "nIndexesWas" : 5,
    "ok" : 1.0000000000000000
}
```

###### Add text index to multi fields

Now, you can run following command.

`db.posts.ensureIndex({title: 'text', 'content.brief': 'text',
'content.extended': 'text'});

Once shows result as following, the new index is added.

Inserted 1 record(s) in 27ms`

If you run `db.posts.getIndexes()`, you can verify you text index
is added.

```
"4" : {
        "v" : 1,
        "key" : {
            "_fts" : "text",
            "_ftsx" : 1
        },
        "name" : "title_text_content.brief_text_content.extended_text",
        "ns" : "dake-tech.posts",
        "weights" : {
            "content.brief" : 1,
            "content.extended" : 1,
            "title" : 1
        },
        "default_language" : "english",
        "language_override" : "language",
        "textIndexVersion" : 2
    }
```

Also, if you the index validation `db.posts.validate()`, you can
see that new text index has index `31429`key words.`"dake-tech.posts.$title_text_content.brief_text_content.extended_text" :
31429Compare before just title only 1464` was indexed. Now, I'd like
to run the same text search query again, it's the fun time!!

```
{
    "ns" : "dake-tech.posts",
    "datasize" : 4.72926e+006,
    "nrecords" : 325,
    "lastExtentSize" : 1.67772e+007,
    "firstExtent" : "0:ef000 ns:dake-tech.posts",
    "lastExtent" : "0:351000 ns:dake-tech.posts",
    "extentCount" : 4,
    "firstExtentDetails" : {
        "loc" : "0:ef000",
        "xnext" : "0:111000",
        "xprev" : "null",
        "nsdiag" : "dake-tech.posts",
        "size" : 8192,
        "firstRecord" : "0:ef0b0",
        "lastRecord" : "0:f0eb0"
    },
    "lastExtentDetails" : {
        "loc" : "0:351000",
        "xnext" : "null",
        "xprev" : "0:151000",
        "nsdiag" : "dake-tech.posts",
        "size" : 1.67772e+007,
        "firstRecord" : "0:3510b0",
        "lastRecord" : "0:591230"
    },
    "deletedCount" : 5,
    "deletedSize" : 1.44095e+007,
    "nIndexes" : 5,
    "keysPerIndex" : {
        "dake-tech.posts.$_id_" : 325,
        "dake-tech.posts.$slug_1" : 325,
        "dake-tech.posts.$state_1" : 325,
        "dake-tech.posts.$publishedDate_1" : 325,
        "dake-tech.posts.$title_text_content.brief_text_content.extended_text" : 31429
    },
    "valid" : true,
    "errors" : [],
    "warning" : "Some checks omitted for speed. use {full:true} option to do more thorough scan.",
    "ok" : 1.0000000000000000
}
```

You run
`db.posts.find( { $text: { $search: "javascript" } }, { score: { $meta:
"textScore" }} )

![](https://d1p0mp3f1fx0hz.cloudfront.net/_uwqsh0ebl.png)

Mmmm, this is not what I expected, the first result's title is not relative
with Javascript.

### How does Mongodb define score for text search?

I don't have an answer for this yet, this is something I want to figure out.
In the mean time, once your text search is enable, you can try something as
following. You can also find document from MongoDB at
Here.

1. search word
db.post.find( { $text: { $search: "javascript" } } )`

2. search phrase
`db.post.find( { $text: { $search: "javascript angular react" } } )`

3. Exclude Documents that contains term, following will search javascript and
exclude angular from the document
`db.post.find( { $text: { $search: "javascript -angular" } } )`

4. You can search for different language
`db.post.find( { $text: { $search: "javascript", $language: "es" } } )`

5. You can search Case Sensitive
`db.post.find( { $text: { $search: "Javascript", $caseSensitive: true } } )`

6. Case Sensitive for Phrase
`db.post.find( { $text: { $search: "\"Javascript React\"", $caseSensitive:
true } } )`

7. Case Sensitive with exclude term, search Javascript but exclude lower-case
javascript
`db.post.find( { $text: { $search: "Javascript -javascript",
$caseSensitive: true } } )`

8. Diacritic Sensitive Search for a Term

9. Diacritic Sensitivity with Negated Term

10. Return the Text Search Score
`db.posts.find( { $text: { $search: "javascript" } }, { score: { $meta:
"textScore" }} )`

11. Sort by Text Search Score

12. Return Top 2 Matching Documents

13. Text Search with Additional Query and Sort Expressions


How to Setup MongoDB Text Search with Node.js


I have noticed that I've been using Mongodb 2.4, text-search is beta. Some
code like following is not going to work. outputDeal is null.

```
mycollection.textSearch(req.body.searchBox, searchOpt, function (err, outputDeal) {
        var result = inspect(outputDeal, { depth: null });
        console.info(result);
    })

MongoDB 2.6 has more feature, see following for reference.
MongoDB 2.6 is now available. Key features include aggregation enhancements, text-search integration, query-engine improvements, a new write-operation protocol, and security enhancements.

```

SO this blog provide how to upgrade from 2.4 to 2.6 by following steps.

1. dump your mongodb data

2. download binary 2.6 file.

3. stop all service, app using the mongodb

4. go to mongo bin folder and replace all the dll by using the new 2.6 dll.

5. restart all service, app using the mongodb.

6. you should be able to verify 2.6 by type db.version()

after I change in above steps, I could verify my first text search query is
working now.


Mongodb 2.6 upgrade


#### Table of Contents

1. How to use MongoDB text search with Mongoose
2. Mongodb need to be 2.4 or higher
3. Other References
4. Other Search Engine

This blog shows example code of how to use MongoDB's text search by use
Mongoose. You can also find What's
[Mongoose Text Search at here.

### How to use MongoDB text search with Mongoose

First, install following npm module.

mongoose-text-search

```
textSearch = require('mongoose-text-search')
```

set up your schema

```
// give schema text search capabilities
yourMongooseSchema.plugin(textSearch);
// add a text index
yourMongooseSchema.index(
{
    Title: 'text'
});
```

Following is example how to use text search.

```
var option = {
        // list of schema property you do not want to include
        project: '-DealId -DealSiteId -Title'
        // casts queries based on schema
        , filter: { likes: { $gt: 1000000 }}
        , limit: 10
        , language: 'spanish'
          , lean: true
    };

var keyWord = 'key word to search'
yourCollection.textSearch(keyWord , option, function (err, output)
{
}

More about Mongoose with MongoDB text search, check mongoose-text-search](../../blog/post/mongodb-text-search).
```

### Mongodb need to be 2.4 or higher

### Other References

[Blog -MongoDB Text Search Explained

Enable Text Search

MongoDB release note 3.0

MongoDB release note 3.2

$text

Text Searching with MongoDB

### Other Search Engine

Want to use other popular search engine?

Solr](https://blog.codecentric.de/en/2013/01/text-search-mongodb-stemming/)

    - [Solr.NET](https://github.com/mausch/SolrNet)

[elastic](https://www.elastic.co/)

    - Elasticsearch.NET


Category Mongoose